// ---------------------------------------
// Template: cls.cs	rel: 3.0.0.0 NoDal
// ---------------------------------------
using System;
using System.Data;
using IGCal.Collections;
using IGCal.Funzioni;
using IGCal.DB;

namespace Calcio.StampaDistinta
{
	/// <summary>
	/// Middle tier per accedere alla tabella PresenzeGaraDirigenti
	/// </summary>
	public class PresenzeGaraDirigenteCollection : IGCalNameObjectCollectionBase
	{

		/// <summary>
		/// Crea una nuova istanza della collection
		/// </summary>
		public PresenzeGaraDirigenteCollection()
		{
		}

		/// <summary>
		/// Recupera PresenzeGaraDirigente dalla collection
		/// </summary>
		public PresenzeGaraDirigente this[string ID]
		{
			get
			{
				PresenzeGaraDirigente PresenzeGaraDirigente = new PresenzeGaraDirigente();
				
				PresenzeGaraDirigente.SetID(ID);
				
				
				PresenzeGaraDirigente = (PresenzeGaraDirigente) base.BaseGet(PresenzeGaraDirigente.ID);

				return PresenzeGaraDirigente;
			}
		}

		/// <summary>
		/// Indexer
		/// </summary>
		public PresenzeGaraDirigente this[int Index]
		{
			get
			{
				return (PresenzeGaraDirigente)this.BaseGet(Index);
			}
		}



		/// <summary>
		/// Rigenera la collection leggendo dalla tabella PresenzeGaraDirigenti
		/// </summary>
		/// <param name="connection">Connessione al database da cui leggere</param>
		/// <param name="sqlWhere">Clausola where da utilizzare nella query (null o "" per leggere tutti i record)</param>
		public void Refresh(Connection connection, string sqlWhere)
		{
			base.BaseClear();

			DataTable dataTable;
			PresenzeGaraDirigente PresenzeGaraDirigente;

			string sql = GetQuery(sqlWhere);

			dataTable = connection.GetDataTable(sql);

			foreach (DataRow row in dataTable.Rows)
			{
				PresenzeGaraDirigente = new PresenzeGaraDirigente();
				PresenzeGaraDirigente.ReadFromRow(row);
				base.BaseAdd(PresenzeGaraDirigente.ID, PresenzeGaraDirigente);
			}
		}

		/// <summary>
		/// Recupera PresenzeGaraDirigente dalla tabella PresenzeGaraDirigenti
		/// </summary>
		/// <param name="connection">Connessione al database da cui leggere</param>
		/// <param name="ID">ID</param>
		/// <returns>PresenzeGaraDirigente</returns>
		public static PresenzeGaraDirigente Read(Connection connection, int ID)
		{
			PresenzeGaraDirigente PresenzeGaraDirigente;

			DataRow row;

			try
			{
				row = GetRecord(connection, null, ID);
			}
			catch
			{
				return null;
			}

			PresenzeGaraDirigente = new PresenzeGaraDirigente();
			PresenzeGaraDirigente.ReadFromRow(row);
			return PresenzeGaraDirigente;
		}

		/// <summary>
		/// Costruisce la query sulla tabella
		/// </summary>
		/// <param name="SQLWhere">Clausola where da utilizzare nella query (null o string.Empty per leggere tutti i record)</param>
		/// <returns>La query</returns>
		private static string GetQuery(string SQLWhere)
		{
			string SQL = "Select *, ";
			SQL += "RuoliDirigentiInGara.Ordine as OrdineRuolo, ";
			SQL += "RuoliDirigentiInGara.ID as IDRuolo ";
			SQL += "FROM ";
			SQL += "(PresenzeGaraDirigenti ";
			SQL += "Left Outer Join ";
			SQL += "RuoliDirigentiInGara On ";
			SQL += "    RuoliDirigentiInGara.ID = PresenzeGaraDirigenti.IDRuoloDirigenteInGara) ";


			if (SQLWhere == null || SQLWhere == string.Empty)
				return SQL + " Order By RuoliDirigentiInGara.Ordine ASC ";
			else
				return SQL + " Where " + SQLWhere + " Order By RuoliDirigentiInGara.Ordine ASC ";
		}

		/// <summary>
		/// Costruisce la query sulla tabella
		/// </summary>
		/// <param name="SQLWhere">Clausola where da utilizzare nella query (null o string.Empty per leggere tutti i record)</param>
		/// <returns>La query</returns>
		private static string GetQueryBase(string SQLWhere)
		{
			string SQL = "Select * ";
			SQL += "FROM ";
			SQL += " PresenzeGaraDirigenti ";
		

			if (SQLWhere == null || SQLWhere == string.Empty)
				return SQL;
			else
				return SQL + " Where " + SQLWhere;
		}
		/// <summary>
		/// Inserisce l'elemento nella tabella
		/// </summary>
		/// <param name="connection">Connessione</param>
		/// <param name="PresenzeGaraDirigente">Elemento da inserire nella tabella</param>
		public static void Insert(Connection connection, PresenzeGaraDirigente presenzeGaraDirigente)
		{
			string SQL = GetQueryBase("1 = 2");
			DataAdapter dataAdapter = connection.GetDataAdapter();
			DataTable dataTable = connection.GetDataTable(dataAdapter, SQL);

			DataRow row = dataTable.NewRow();
			presenzeGaraDirigente.WriteToRow(row);
			dataTable.Rows.Add(row);

			dataAdapter.Update(dataTable);

			dataAdapter.Dispose();
		}


		/// <summary>
		/// Recupera un record dalla tabella (se non c'e' o ce ne sono piu' di uno viene rilanciata un'eccezione)
		/// </summary>
		/// <param name="connection">Connessione</param>
		/// <param name="dataAdapter">DataAdapter nel caso in cui la tabella debba essere aperta in scrittura</param>
		/// <param name="ID">ID</param>
		/// <returns>La DataRow relativa al record</returns>
		private static DataRow GetRecord(Connection connection, DataAdapter dataAdapter, int ID)
		{
			string SQLWhere = null;
			DataTable dataTable;

			SQLWhere += string.Format(" And ID = {0}", ID);

			string SQL = GetQuery(SQLWhere.Substring(4));

			if (dataAdapter != null)
				dataTable = connection.GetDataTable(dataAdapter, SQL);
			else
				dataTable = connection.GetDataTable(SQL);

			if (dataTable.Rows.Count == 0)
				throw new Exception("Record non trovato");

			if (dataTable.Rows.Count > 1)
				throw new Exception("La chiave primaria non identifica solo un record");

			return dataTable.Rows[0];
		}

		internal void Clear()
		{
			base.BaseClear();
		}
	}







	/// <summary>
	/// Middle tier per accedere ad un record della tabella PresenzeGaraDirigenti
	/// </summary>
	public class PresenzeGaraDirigente
	{
		private string _ID;
		private int _IDGara;
		private int _IDDirigente;
		private int _IDRuoloDirigenteInGara;
		private string _TipoDocumento;
		private string _CodiceDocumento;
		private string _ProvenienzaDocumento;
		private int _NumeroDocumento;

		/// <summary>
		/// Crea una nuova istanza della classe
		/// </summary>
		public PresenzeGaraDirigente()
		{
		}

		/// <summary>
		/// Legge le propriet� della classe dalla row
		/// </summary>
		/// <param name="row">Row da leggere</param>
		public void ReadFromRow(DataRow row)
		{
			_ID = General.DBToString(row["ID"]);
			_IDGara = General.DBToInt(row["IDGara"]);
			_IDDirigente = General.DBToInt(row["IDDirigente"]);
			_IDRuoloDirigenteInGara = General.DBToInt(row["IDRuoloDirigenteInGara"]);
			_TipoDocumento = General.DBToString(row["TipoDocumento"]);
			_CodiceDocumento = General.DBToString(row["CodiceDocumento"]);
			_ProvenienzaDocumento = General.DBToString(row["ProvenienzaDocumento"]);
			_NumeroDocumento = General.DBToInt(row["NumeroDocumento"]);
		}

		internal void WriteToRow(DataRow row)
		{
			row["ID"] = General.StringToDB(_ID);
			row["IDGara"] = General.IntToDB(_IDGara);
			row["IDDirigente"] = General.IntToDB(_IDDirigente);
			row["IDRuoloDirigenteInGara"] = General.IntToDB(_IDRuoloDirigenteInGara);
			row["TipoDocumento"] = General.StringToDB(_TipoDocumento);
			row["CodiceDocumento"] = General.StringToDB(_CodiceDocumento);
			row["ProvenienzaDocumento"] = General.StringToDB(_ProvenienzaDocumento);
			row["NumeroDocumento"] = General.IntToDB(_NumeroDocumento);
		}


		/// <summary>
		/// Legge/Imposta ID
		/// </summary>
		public string ID
		{
			get
			{
				return _ID;
			}

		}

		/// <summary>
		/// Imposta ID
		/// </summary>
		/// <param name="ID">nuovo valore diID</param>
		internal void SetID(string ID)
		{
			_ID = ID;
		}

		/// <summary>
		/// Legge/Imposta IDGara
		/// </summary>
		public int IDGara
		{
			get
			{
				return _IDGara;
			}

			set
			{
				_IDGara = value;
			}
		}
		/// <summary>
		/// Legge/Imposta IDDirigente
		/// </summary>
		public int IDDirigente
		{
			get
			{
				return _IDDirigente;
			}

			set
			{
				_IDDirigente = value;
			}
		}
		/// <summary>
		/// Legge/Imposta IDRuoloDirigenteInGara
		/// </summary>
		public int IDRuoloDirigenteInGara
		{
			get
			{
				return _IDRuoloDirigenteInGara;
			}

			set
			{
				_IDRuoloDirigenteInGara = value;
			}
		}
		/// <summary>
		/// Legge/Imposta TipoDocumento
		/// </summary>
		public string TipoDocumento
		{
			get
			{
				return _TipoDocumento;
			}

			set
			{
				_TipoDocumento = value;
			}
		}
		/// <summary>
		/// Legge/Imposta CodiceDocumento
		/// </summary>
		public string CodiceDocumento
		{
			get
			{
				return _CodiceDocumento;
			}

			set
			{
				_CodiceDocumento = value;
			}
		}
		/// <summary>
		/// Legge/Imposta ProvenienzaDocumento
		/// </summary>
		public string ProvenienzaDocumento
		{
			get
			{
				return _ProvenienzaDocumento;
			}

			set
			{
				_ProvenienzaDocumento = value;
			}
		}
		/// <summary>
		/// Legge/Imposta NumeroDocumento
		/// </summary>
		public int NumeroDocumento
		{
			get
			{
				return _NumeroDocumento;
			}

			set
			{
				_NumeroDocumento = value;
			}
		}
	
		/// <summary>
		/// Confronta gli elementi
		/// </summary>
		/// <param name="a">Primo elemento</param>
		/// <param name="b">Secondo elemento</param>
		/// <returns>true se gli elementi sono uguali altrimenti false</returns>
		public static bool operator == (PresenzeGaraDirigente a, PresenzeGaraDirigente b)
		{
			if (object.Equals(a, null))
				return (object.Equals(b, null));
			else if (object.Equals(b, null))
				return false;
			else
				return (a._ID == b._ID);
		}

		/// <summary>
		/// Confronta gli elementi
		/// </summary>
		/// <param name="a">Primo elemento</param>
		/// <param name="b">Secondo elemento</param>
		/// <returns>true se gli elementi sono diversi altrimenti false</returns>
		public static bool operator != (PresenzeGaraDirigente a, PresenzeGaraDirigente b)
		{
			if (object.Equals(a, null))
				return (!object.Equals(b, null));
			else if (object.Equals(b, null))
				return true;
			else
				return !(a._ID == b._ID);
		}

		/// <summary>
		/// Confronta l'elemento corrente con l'elemento specificato
		/// </summary>
		/// <param name="obj">Oggetto da confrontare</param>
		/// <returns>true se gli elementi sono uguali altrimenti false</returns>
		public override bool Equals(object obj)
		{
			if (obj is PresenzeGaraDirigente)
			{
				PresenzeGaraDirigente PresenzeGaraDirigente = (PresenzeGaraDirigente) obj;
				return (PresenzeGaraDirigente._ID == this._ID);
			}

			return base.Equals(obj);
		}



	
	}
}

